home *** CD-ROM | disk | FTP | other *** search
/ Mission 3 / Mission 3.zip / Mission 3.iso / texte / qed / src / winlist.c < prev    next >
C/C++ Source or Header  |  1998-03-15  |  6KB  |  320 lines
  1. /*
  2.  * Listenverwaltung für die Fenster.
  3.  *
  4.  * Es gibt zwei verschiedene Listen:
  5.  *        used_list: - enthält alle offenen Fenster
  6.  *                      - erstes Element ist das Top-Window
  7.  *                      - einfach verkettet
  8.  *
  9.  *        free_list: - enthält die unbenutzten Fenster, deren Größe bekannt ist
  10.  *                      - einfach verkettet mit Reihenfolge des w->init
  11.  *
  12.  * Wird ein neues Fenster benötigt, wird in der free_list nach dem mit dem
  13.  * kleinsten init der entsprechenden Klasse gesucht. Wird keins gefunden,
  14.  * wird in der free_list ein neues Element angehängt.
  15.  * Das Fenster aus der free_list wird dann in die used_list umgehängt und in
  16.  * der free_list gelöscht.
  17.  * Wird ein Fenster nicht mehr benötigt, wird es in used_list gelöscht und in
  18.  * free_list entsprechend seinem init einsortiert.
  19.  * Das erste Fenster einer Klasse steht in free_list immer ganz vorne.
  20. */
  21. #include "global.h"
  22. #include "qed.h"
  23. #include "winlist.h"
  24.  
  25. WINDOWP    used_list;
  26.  
  27. static WINDOWP    free_list;
  28. static int        init_count;
  29.  
  30. #if 0
  31. void dump_winlist(void)
  32. {
  33.     WINDOWP    p;
  34.  
  35.     p = used_list;
  36.     Debug("used_list:\n");
  37.     while (p)
  38.     {
  39.         Debug(" class= %d, init= %d, title= %s\n", p->class, p->init, p->title);
  40.         p = p->next;
  41.     }
  42.  
  43.     p = free_list;
  44.     Debug("free_list:\n");
  45.     while (p)
  46.     {
  47.         Debug(" class= %d, init= %d, title= %s\n", p->class, p->init, p->title);
  48.         p = p->next;
  49.     }
  50.     Debug("\n");
  51. }
  52. #endif
  53.  
  54. /*
  55.  * free_list: Neues Element in die Liste einhängen.
  56. */
  57. static WINDOWP new_list_elem(int class)
  58. {
  59.     WINDOWP    new, p;
  60.  
  61.     new = (WINDOWP)calloc(1, sizeof(WINDOW));
  62.     if (new != NULL)
  63.     {
  64.         new->next = NULL;
  65.  
  66.         if (free_list == NULL)                /* Erstes Element -> Wurzel */
  67.             free_list = new;
  68.         else
  69.         {
  70.             p = free_list;
  71.  
  72.             while (p->next != NULL)            /* Am Ende der Liste anhängen */
  73.                 p = p->next;
  74.             p->next = new;
  75.         }
  76.         new->class = class;
  77.         new->handle = UNUSED;
  78.         new->init = init_count;
  79.         init_count++;
  80.         return new;
  81.     }
  82.     else
  83.         note(1, 0, NOMEMORY);
  84.     return NULL;
  85. }
  86.  
  87. #if 0
  88. /*
  89.  * Ein Element löschen.
  90. */
  91. static void del_list_elem(WINDOWP w)
  92. {
  93.     if (w == win_list)                    /* Wurzel? */
  94.         win_list = win_list->next;
  95.     else
  96.     {
  97.         WINDOWP    p = win_list;
  98.  
  99.         while (p->next != w)                /* Vorgänger suchen */
  100.             p = p->next;
  101.         p->next = w->next;                /* und Aushängen */
  102.     }
  103.     free(w);
  104.     w = NULL;
  105. }
  106.  
  107. /*
  108.  * Gesamte Listen löschen
  109. */
  110. static void kill_list(void)
  111. {
  112.     while (win_list != NULL)
  113.         del_list_elem(win_list);
  114. }
  115. #endif
  116.  
  117. /*
  118.  * Fenster aus einer Liste aushänge, aber nicht löschen!
  119. */
  120. static void unlink_elem(WINDOWP *list, WINDOWP w)
  121. {
  122.     if (w == *list)                        /* Wurzel? */
  123.         *list = (*list)->next;
  124.     else
  125.     {
  126.         WINDOWP    p = *list;
  127.  
  128.         while (p->next != w)                /* Vorgänger suchen */
  129.             p = p->next;
  130.         p->next = w->next;                /* und Aushängen */
  131.     }
  132. }
  133.  
  134. /*
  135.  * Fenster aus der free_list an den Anfang der used_list.
  136. */
  137. static void free_to_used(WINDOWP w)
  138. {
  139.     unlink_elem(&free_list, w);
  140.  
  141.     if (used_list == NULL)
  142.     {
  143.         used_list = w;
  144.         w->next = NULL;
  145.     }
  146.     else
  147.     {
  148.         w->next = used_list;
  149.         used_list = w;
  150.     }
  151. }
  152.  
  153. /*
  154.  * Fenster aus der used_list in die free_list einsortieren.
  155. */
  156. static void used_to_free(WINDOWP w)
  157. {
  158.     WINDOWP    p, last;
  159.     
  160.     unlink_elem(&used_list, w);
  161.  
  162.     p = free_list;
  163.     if (free_list == NULL)                    /* kein Element */
  164.     {
  165.         free_list = w;
  166.         w->next = NULL;
  167.     }
  168.     else if (w->init < free_list->init)    /* vor dem ersten einfügen */
  169.     {
  170.         w->next = free_list;
  171.         free_list = w;
  172.     }
  173.     else
  174.     {
  175.         p = free_list;
  176.         last = free_list;
  177.         while ((p) && (p->init < w->init))
  178.         {
  179.             last = p;
  180.             p = p->next;
  181.         }
  182.         w->next = last->next;
  183.         last->next = w;
  184.     }
  185. }
  186.  
  187. /*
  188.  * used_list: Listenelement ganz an Anfang bzw. Ende
  189. */
  190. void move_to_top(WINDOWP w)
  191. {
  192.     WINDOWP p;
  193.  
  194.     if (used_list == NULL)
  195.         return;
  196.  
  197.     if (w == used_list)                         /* ist schon oben */
  198.         return;
  199.  
  200.     p = used_list;
  201.     while (p->next != w)                        /* Vorgänger suchen */
  202.         p = p->next;
  203.     p->next = w->next;
  204.     w->next = used_list;
  205.     used_list = w;
  206. }
  207.  
  208. void move_to_end (WINDOWP w)
  209. {
  210.     WINDOWP p;
  211.  
  212.     if (used_list == NULL)
  213.         return;
  214.  
  215.     if (w->next == NULL)                        /* ist schon letzter */
  216.         return;
  217.  
  218.     if (w == used_list)                        /* ist erster */
  219.         used_list = w->next;
  220.     else                                            /* mitten drin */
  221.     {
  222.         p = used_list;
  223.         while (p->next != w)                    /* Vorgänger suchen */
  224.             p = p->next;
  225.         p->next = w->next;
  226.     }
  227.     p = used_list;
  228.     while (p->next != NULL)                    /* letzten suchen */
  229.         p = p->next;
  230.     p->next = w;
  231.     w->next = NULL;
  232. }
  233.  
  234. /*
  235.  * Abmessungen eines Fensters aus der Konfig in die Liste einhängen
  236. */
  237. void add_winlist(int class, GRECT *r)
  238. {
  239.     WINDOWP    w;
  240.  
  241.     w = new_list_elem(class);
  242.     if (w)
  243.         w->work = *r;
  244. }
  245.  
  246. /*
  247.  * Fensterparameter sichern.
  248. */
  249. static WINDOWP search_init(WINDOWP list, int init)
  250. {
  251.     WINDOWP    p = list;
  252.     
  253.     while (p)
  254.     {
  255.         if (p->init == init)
  256.             break;
  257.         p = p->next;
  258.     }    
  259.     return p;
  260. }
  261.  
  262. void save_winlist(FILE *fd)
  263. {
  264.     int        i;
  265.     WINDOWP    p;
  266.         
  267.     i = 0;
  268.     while (i < init_count)
  269.     {
  270.         p = search_init(used_list, i);
  271.         if (!p)
  272.             p = search_init(free_list, i);
  273.         if (p)
  274.             fprintf(fd, "Window=%d %d %d %d %d\n", p->class,  
  275.                             p->work.g_x, p->work.g_y, p->work.g_w, p->work.g_h);
  276.         i++;
  277.     }
  278. }
  279.  
  280. /*
  281.  * Freies Fenster einer Klasse suchen, ggf. neu anlegen.
  282. */
  283. WINDOWP get_new_window(int class)
  284. {
  285.     WINDOWP    p;
  286.     
  287.     p = free_list;
  288.     while (p)                                /* zunächst unbenutzes suchen */
  289.     {
  290.         if ((p->handle == UNUSED) && (p->class == class))
  291.             break;
  292.         p = p->next;
  293.     }
  294.     if (p == NULL)                            /* kein unbenutztes gefunden */
  295.         p = new_list_elem(class);
  296.     free_to_used(p);
  297.     return p;
  298. }
  299.  
  300. /*
  301.  * Fenster freigeben.
  302. */
  303. void free_window(WINDOWP w)
  304. {
  305.     used_to_free(w);
  306.     w->handle = UNUSED;
  307. }
  308.  
  309.  
  310. void init_winlist(void)
  311. {
  312.     used_list = NULL;
  313.     free_list = NULL;
  314.     init_count = 0;
  315. }
  316.  
  317. void term_winlist(void)
  318. {
  319. }
  320.